/**
 * 中国象棋游戏规则（将军、绝杀等）
 */

import { COLORS, PIECE_TYPES } from '../constants/pieces.js';
import { GAME_STATUS, MOVE_RESULT } from '../constants/gameConfig.js';
import { isValidPieceMove, getAllPossibleMoves } from './moveRules.js';
import { cloneBoard } from '../engine/BoardUtils.js';

/**
 * 检查指定颜色的王是否被将军
 */
export function isInCheck(board, color) {
  const kingPosition = findKingPosition(board, color);
  if (!kingPosition) {
    return false; // 找不到王，可能是测试用例
  }

  const opponentColor = color === COLORS.RED ? COLORS.BLACK : COLORS.RED;
  const opponentMoves = getAllPossibleMoves(board, opponentColor);

  // 检查对手的任何一步棋是否能攻击到王
  return opponentMoves.some(move => 
    move.to.row === kingPosition.row && move.to.col === kingPosition.col
  );
}

/**
 * 查找指定颜色的王的位置
 */
export function findKingPosition(board, color) {
  const kingName = color === COLORS.RED ? '帥' : '將';
  
  for (let row = 0; row < 10; row++) {
    for (let col = 0; col < 9; col++) {
      const piece = board[row][col];
      if (piece && piece.name === kingName) {
        return { row, col };
      }
    }
  }
  return null;
}

/**
 * 检查移动后是否会导致自己被将军
 */
export function wouldBeInCheckAfterMove(board, from, to, color) {
  try {
    // 基本验证
    if (!board || !from || !to || !color) {
      console.warn(`⚠️ wouldBeInCheckAfterMove 参数无效`);
      return false; // 参数无效时假设安全
    }
    
    // 检查位置是否有效
    if (from.row < 0 || from.row >= 10 || from.col < 0 || from.col >= 9 ||
        to.row < 0 || to.row >= 10 || to.col < 0 || to.col >= 9) {
      console.warn(`⚠️ 位置超出边界: from(${from.row},${from.col}) to(${to.row},${to.col})`);
      return false;
    }
    
    // 检查起始位置是否有棋子
    const piece = board[from.row][from.col];
    if (!piece) {
      console.warn(`⚠️ 起始位置(${from.row},${from.col})没有棋子`);
      return false;
    }
    
    // 检查是否是正确颜色的棋子
    if (piece.color !== color) {
      console.warn(`⚠️ 棋子颜色不匹配: ${piece.color} vs ${color}`);
      return false;
    }
    
    // 复制棋盘
    const tempBoard = cloneBoard(board);
    
    // 执行移动
    const movePiece = tempBoard[from.row][from.col];
    tempBoard[to.row][to.col] = movePiece;
    tempBoard[from.row][from.col] = null;
    
    // 更新棋子位置信息
    if (movePiece) {
      movePiece.position = { row: to.row, col: to.col };
    }

    // 检查移动后是否被将军
    return isInCheck(tempBoard, color);
  } catch (error) {
    console.error(`❌ wouldBeInCheckAfterMove 出错:`, error);
    // console.log(`🔍 错误详情: from(${from.row},${from.col}) to(${to.row},${to.col}) color=${color}`);
    // 出错时假设移动是安全的，避免所有移动都被过滤
    return false;
  }
}

/**
 * 检查移动是否合法（包括基本规则和游戏规则）
 */
export function isValidMove(board, from, to, color) {
  // 检查基本移动规则
  if (!isValidPieceMove(from, to, board)) {
    return false;
  }

  const piece = board[from.row][from.col];
  
  // 检查是否是当前玩家的棋子
  if (!piece || piece.color !== color) {
    return false;
  }

  // 检查移动后是否会导致自己被将军
  if (wouldBeInCheckAfterMove(board, from, to, color)) {
    return false;
  }

  return true;
}

/**
 * 获取指定颜色的所有合法移动
 */
export function getAllValidMoves(board, color) {
  const allMoves = getAllPossibleMoves(board, color);
  
  // console.log(`📋 getAllValidMoves - 颜色: ${color}, 所有可能移动: ${allMoves.length}个`);
  
  if (allMoves.length === 0) {
    console.error(`🚨 严重错误: getAllPossibleMoves返回0个移动！`);
    return [];
  }
  
  // 过滤掉会导致自己被将军的移动
  const validMoves = [];
  let filteredCount = 0;
  
  for (const move of allMoves) {
    try {
      const wouldBeInCheck = wouldBeInCheckAfterMove(board, move.from, move.to, color);
      if (!wouldBeInCheck) {
        validMoves.push(move);
      } else {
        filteredCount++;
      }
    } catch (error) {
      console.error(`❌ 移动验证出错:`, move, error);
      // 出错的移动也加入，避免全部被过滤
      validMoves.push(move);
    }
  }
  
  // console.log(`✅ 过滤结果: 有效移动 ${validMoves.length}个, 被过滤 ${filteredCount}个`);
  
  if (validMoves.length === 0 && allMoves.length > 0) {
    console.error(`🚨 严重错误: 所有移动都被过滤掉了！这表示wouldBeInCheckAfterMove函数可能有bug`);
    console.error(`🔍 详细分析前5个被过滤的移动:`);
    
    for (let i = 0; i < Math.min(5, allMoves.length); i++) {
      const move = allMoves[i];
      console.error(`🎯 移动${i+1}: ${move.piece.name}(${move.from.row},${move.from.col})->(${move.to.row},${move.to.col})`);
      try {
        const tempBoard = cloneBoard(board);
        const piece = tempBoard[move.from.row][move.from.col];
        tempBoard[move.to.row][move.to.col] = piece;
        tempBoard[move.from.row][move.from.col] = null;
        const inCheck = isInCheck(tempBoard, color);
        console.error(`   结果: ${inCheck ? '会被将军' : '安全'}`);
      } catch (error) {
        console.error(`   错误:`, error.message);
      }
    }
    
    // 返回空数组，表示无合法移动（可能是将死或困毙）
    console.error(`⚠️ 返回空数组，游戏应该结束`);
    return [];
  }
  
  return validMoves;
}

/**
 * 检查是否为将死（checkmate）
 */
export function isCheckmate(board, color) {
  // 首先必须被将军
  if (!isInCheck(board, color)) {
    return false;
  }

  // 检查是否有任何合法移动可以解除将军
  const validMoves = getAllValidMoves(board, color);
  return validMoves.length === 0;
}

/**
 * 检查是否为困毙（stalemate）
 */
export function isStalemate(board, color) {
  // 不被将军但无法移动
  if (isInCheck(board, color)) {
    return false;
  }

  const validMoves = getAllValidMoves(board, color);
  return validMoves.length === 0;
}

/**
 * 检查是否为和棋
 */
export function isDraw(board, moveHistory) {
  // 1. 检查是否为困毙
  // 这个在外部调用 isStalemate 检查

  // 2. 检查重复局面（简化版：连续3次相同移动）
  if (moveHistory.length >= 6) {
    const recent = moveHistory.slice(-6);
    const move1 = recent[0];
    const move2 = recent[1];
    const move3 = recent[2];
    const move4 = recent[3];
    const move5 = recent[4];
    const move6 = recent[5];

    // 检查是否为 A-B-A-B-A-B 的重复模式
    if (movesEqual(move1, move3) && movesEqual(move3, move5) &&
        movesEqual(move2, move4) && movesEqual(move4, move6)) {
      return true;
    }
  }

  // 3. 检查子力不足（简化版：只剩双王）
  let pieceCount = 0;
  let hasAttackingPiece = false;

  for (let row = 0; row < 10; row++) {
    for (let col = 0; col < 9; col++) {
      const piece = board[row][col];
      if (piece) {
        pieceCount++;
        if (piece.type !== PIECE_TYPES.KING) {
          hasAttackingPiece = true;
        }
      }
    }
  }

  // 只剩双王
  if (pieceCount === 2 && !hasAttackingPiece) {
    return true;
  }

  return false;
}

/**
 * 检查两个移动是否相等
 */
function movesEqual(move1, move2) {
  return move1.from.row === move2.from.row &&
         move1.from.col === move2.from.col &&
         move1.to.row === move2.to.row &&
         move1.to.col === move2.to.col;
}

/**
 * 详细验证移动并返回具体错误信息
 */
export function validateMoveWithDetails(board, from, to, color) {
  // 检查起始位置是否有棋子
  const piece = board[from.row][from.col];
  if (!piece) {
    return {
      isValid: false,
      errorMessage: '起始位置没有棋子'
    };
  }

  // 检查是否是当前玩家的棋子
  if (piece.color !== color) {
    return {
      isValid: false,
      errorMessage: '不能移动对方的棋子'
    };
  }

  // 检查基本移动规则
  if (!isValidPieceMove(from, to, board)) {
    const pieceNames = {
      'king': '帥/將',
      'advisor': '仕/士', 
      'elephant': '相/象',
      'rook': '車',
      'knight': '馬',
      'cannon': '砲/炮',
      'pawn': '兵/卒'
    };
    const pieceName = pieceNames[piece.type] || piece.name;
    return {
      isValid: false,
      errorMessage: `${pieceName}不能这样移动`
    };
  }

  // 检查移动后是否会导致自己被将军
  if (wouldBeInCheckAfterMove(board, from, to, color)) {
    return {
      isValid: false,
      errorMessage: '此移动会导致己方被将军'
    };
  }

  return {
    isValid: true,
    errorMessage: null
  };
}

/**
 * 执行移动并返回结果
 */
export function makeMove(board, from, to, currentPlayer) {
  // 使用详细验证，提供具体的错误信息
  const validation = validateMoveWithDetails(board, from, to, currentPlayer);
  
  if (!validation.isValid) {
    console.warn(`❌ 移动验证失败: ${validation.errorMessage}`, {
      from,
      to,
      currentPlayer,
      piece: board[from.row]?.[from.col]
    });
    return {
      success: false,
      result: MOVE_RESULT.INVALID,
      message: validation.errorMessage
    };
  }

  // 复制棋盘执行移动
  const newBoard = cloneBoard(board);
  const piece = newBoard[from.row][from.col];
  const capturedPiece = newBoard[to.row][to.col];
  
  // 执行移动
  newBoard[to.row][to.col] = piece;
  newBoard[from.row][from.col] = null;
  
  // 更新棋子位置
  if (piece) {
    piece.position = { row: to.row, col: to.col };
    piece.moveCount = (piece.moveCount || 0) + 1;
  }

  const opponentColor = currentPlayer === COLORS.RED ? COLORS.BLACK : COLORS.RED;
  const moveInfo = {
    from,
    to,
    piece: { ...piece },
    capturedPiece: capturedPiece ? { ...capturedPiece } : null
  };

  // 检查移动结果
  let result = MOVE_RESULT.VALID;
  let gameStatus = GAME_STATUS.PLAYING;
  let message = '';

  // 检查是否吃子
  if (capturedPiece) {
    result = MOVE_RESULT.CAPTURE;
    message = `${piece.symbol}吃${capturedPiece.symbol}`;
  }

  // 检查是否将军
  if (isInCheck(newBoard, opponentColor)) {
    result = MOVE_RESULT.CHECK;
    message = '将军！';

    // 检查是否将死
    if (isCheckmate(newBoard, opponentColor)) {
      result = MOVE_RESULT.CHECKMATE;
      gameStatus = GAME_STATUS.CHECKMATE;
      message = '将死！游戏结束！';
    }
  }

  // 检查是否困毙或和棋
  if (gameStatus === GAME_STATUS.PLAYING) {
    if (isStalemate(newBoard, opponentColor)) {
      gameStatus = GAME_STATUS.STALEMATE;
      message = '困毙！游戏和棋！';
    }
  }

  return {
    success: true,
    board: newBoard,
    result,
    gameStatus,
    message,
    moveInfo,
    isCheck: isInCheck(newBoard, opponentColor),
    validMovesCount: getAllValidMoves(newBoard, opponentColor).length
  };
}

/**
 * 获取指定位置棋子的所有合法移动
 */
export function getValidMovesForPiece(board, position, color) {
  const { row, col } = position;
  const piece = board[row][col];
  
  if (!piece || piece.color !== color) {
    return [];
  }

  const moves = [];

  // 遍历所有可能的目标位置
  for (let toRow = 0; toRow < 10; toRow++) {
    for (let toCol = 0; toCol < 9; toCol++) {
      const to = { row: toRow, col: toCol };
      
      if (isValidMove(board, position, to, color)) {
        moves.push(to);
      }
    }
  }

  return moves;
}

/**
 * 检查游戏是否结束
 */
export function checkGameEnd(board, currentPlayer, moveHistory) {
  // 首先检查最基本的游戏结束条件：王是否被吃掉
  const redKing = findKingPosition(board, COLORS.RED);
  const blackKing = findKingPosition(board, COLORS.BLACK);
  
  if (!redKing) {
    // console.log('🎯 游戏结束: 红方帥被吃掉');
    return {
      isEnd: true,
      status: GAME_STATUS.CHECKMATE,
      winner: COLORS.BLACK,
      message: '黑方获胜！红帥被吃！'
    };
  }
  
  if (!blackKing) {
    // console.log('🎯 游戏结束: 黑方將被吃掉');
    return {
      isEnd: true,
      status: GAME_STATUS.CHECKMATE,
      winner: COLORS.RED,
      message: '红方获胜！黑將被吃！'
    };
  }
  
  // 检查将死
  if (isCheckmate(board, currentPlayer)) {
    return {
      isEnd: true,
      status: GAME_STATUS.CHECKMATE,
      winner: currentPlayer === COLORS.RED ? COLORS.BLACK : COLORS.RED,
      message: '将死！游戏结束！'
    };
  }

  // 检查困毙
  if (isStalemate(board, currentPlayer)) {
    return {
      isEnd: true,
      status: GAME_STATUS.STALEMATE,
      winner: null,
      message: '困毙！游戏和棋！'
    };
  }

  // 检查和棋
  if (isDraw(board, moveHistory)) {
    return {
      isEnd: true,
      status: GAME_STATUS.DRAW,
      winner: null,
      message: '和棋！'
    };
  }

  return {
    isEnd: false,
    status: GAME_STATUS.PLAYING,
    winner: null,
    message: ''
  };
}
